Language Design for Reactive Systems: On Modal Models, Time, and Object Orientation in Lingua Franca and SCCharts

Reactive systems play a crucial role in the embedded domain. They continuously interact with their environment, handle concurrent operations, and are commonly expected to provide deterministic behavior to enable application in safety-critical systems. In this context, language design is a key aspect, since carefully tailored language constructs can aid in addressing the challenges faced in this domain, as illustrated by the various concurrency models that prevent the known pitfalls of regular threads. Today, many languages exist in this domain and often provide unique characteristics that make them specifically fit for certain use cases. This thesis evolves around two distinctive languages: the actor-oriented polyglot coordination language Lingua Franca and the synchronous statecharts dialect SCCharts. While they take different approaches in providing reactive modeling capabilities, they share clear similarities in their semantics and complement each other in design principles. This thesis analyzes and compares key design aspects in the context of these two languages. For three particularly relevant concepts, it provides and evaluates lean and seamless language extensions that are carefully aligned with the fundamental principles of the underlying language. Specifically, Lingua Franca is extended toward coordinating modal behavior, while SCCharts receives a timed automaton notation with an efficient execution model using dynamic ticks and an extension toward the object-oriented modeling paradigm

Guidance in Model-based Compilations

The modeler should not be burdened with maintaining an overview over all potential conflicts. They should further be able to understand what is happening. Model-based compilers and modeling tools in general should guide a modeler.The KIELER Compiler constructs transformation snapshots and augmented models automatically during compilation. We demonstrate six different transient views that can help the modeler to refine their models and to solve modeling issues, such as causality problems in synchronous languages

Watch Your Compiler Work Compiler Models and Environments

We can observe many similarities between classical programming paradigms and model-driven engineering. A chain of model-to-model transformations often prescribes a particular work process, while executing such a chain generates a concrete instance of this process. Modeling the entire development process itself on a meta-model level extends the possibilities of the model-based approach to guide the developer. Besides refining tools for model creation, this kind of meta-modeling also facilitates debugging, optimization, and prototyping of new compilations. A compiler is such a process system. In this paper, we share the experiences gathered while we worked on the model-based reference compiler of the KIELER SCCharts project and ideas towards a unified view on similar prescribed processes. We exemplify our approach in two case studies

Practical causality handling for synchronous languages

The synchronous principle is a well-established paradigm for reconciling concurrency with determinism. A key is to establish at compile time that a program or model is causal, which basically means that there exists a schedule that obeys the rules put down by the language. This rules out surprises at run time; however, in practice it can be rather cumbersome for the developer to cure causality problems, in particular as programs/models get more complex. We here propose to tackle this issue in two ways. Firstly, we propose to enrich the scheduling regime allowed by the language to not only consider data dependencies, but also explicit scheduling directives that operate on statements or coarser scheduling units. These directives may be used by the developer, or also by model-to-model transformations within the compiler. Secondly, we propose to enhance programming/modeling environments to guide the developer in finding causality issues. Specifically, we propose dedicated causality views that highlight data dependencies involved in scheduling conflicts, and structure-based editing to efficiently add scheduling directives. We illustrate our proposals for the SCCharts language. An Eclipse-based implementation based on the KIELER framework is available as open source

A sequentially constructive circuit semantics for Esterel

Static Single Assignment (SSA) is an established concept that facilitates various program optimizations. However, it is typically restricted to sequential programming. We present an approach that extends SSA for concurrent, reactive programming, specifically for the synchronous language Esterel. This extended SSA transformation expands the class of programs that can be compiled by existing Esterel compilers without causality problems. It also offers a new, efficient solution for the well-studied signal reincarnation problem. Finally, our approach rules out speculation/backtracking, unlike the recently proposed sequentially constructive model of computation

Using SCCharts models in Simulink to model an electronic control unit

When constructing an electrical racing car, special attention needs to be directed to the development of its engine control unit. Functionality of the motor-torque calculation and the integration of advanced driver assistance systems are crucial for the speed handling and hence, the safety of the car. The Kieler Formula Student Team Raceyard, which since 2011 has been constructing electrical racing cars annually, so far designed and tested its controller model in the popular commercial modeling software MATLAB/Simulink. This work shows how a functionally equivalent system can be designed by utilizing the visual synchronous language SCCharts in the academic open-source project KIELER. A complete controller model is modeled in KIELER and validated to behave the same as the original controller both in Simulink directly as well as in the 3D simulation environment IPG Carmaker. Tests on the performance of both controllers show that while a slowdown can be observed when comparing the generated C Code, simulation time in IPG Carmaker only increases by a negligible factor. KIELER’s developing and testing capabilities for synchronous models can therefore be considered a valuable tool in the process of designing, tuning and documenting such a controller model

Modal Reactors

Complex software systems often feature distinct modes of operation, each designed to handle a particular scenario that may require the system to respond in a certain way. Breaking down system behavior into mutually exclusive modes and discrete transitions between modes is a commonly used strategy to reduce implementation complexity and promote code readability. However, such capabilities often come in the form of self-contained domain specific languages or language-specific frameworks. The work in this paper aims to bring the advantages of modal models to mainstream programming languages, by following the polyglot coordination approach of Lingua Franca (LF), in which verbatim target code (e.g., C, C++, Python, Typescript, or Rust) is encapsulated in composable reactive components called reactors. Reactors can form a dataflow network, are triggered by timed as well as sporadic events, execute concurrently, and can be distributed across nodes on a network. With modal models in LF, we introduce a lean extension to the concept of reactors that enables the coordination of reactive tasks based on modes of operation. The implementation of modal reactors outlined in this paper generalizes to any LF-supported language with only modest modifications to the generic runtime system

SCCharts: The Railway Project Report

SCCharts is a visual language proposed in 2012 for specifying safety-critical reactive systems. We present the results of the first medium sized SCCharts case-study. The case-study was conducted in the context of the railway project performed by students at the Kiel University in the summer term 2014. The railway project is a regularly occurring student training project that teaches principles of concurrent cyber-physical systems on a complex live model railway demonstrator. This report presents details of the first medium size SCCharts models created during the project. We explain what additional language extensions to SCCharts were necessary and how they were implemented. To handle performance issues that arose while developing the controller, compiler enhancements became necessary and are evaluated here. Furthermore, the participants completed a survey at the end of the project to confirm the goals that the SCCharts language and our SCCharts tool chain are suitable to build complex controllers. In the survey, the participants compared both, the SCCharts language and our SCCharts tools, with other modeling and classical programming languages and tools

SCCharts: The Mindstorms Report

SCCharts are a visual language proposed in 2012 for specifying safety-critical reactive systems. This is the second SCCharts report towards the usability of the SCCharts visual language and its KIELER SCCharts implementation. KIELER is an open-source project which researches the pragmatics of model-based languages and related fields. Nine case-studies that were conducted between 2015 and 2019 evaluate the pros and cons in the context of small-scale Lego Mindstorms models and similar projects. Par-ticipants of the studies included undergraduate and graduate students from our local and also external facilities, as well as academics from the synchronous community. In the surveys, both the SCCharts language and the SCCharts tools are compared to other modeling and classical programming languages and tools

Time for Reactive System Modeling : Interactive Timing Analysis with Hotspot Highlighting

Modeling tools typically provide no information about timing properties and costly parts of the system under development. In this paper we propose a generic approach to integrate timing analysis and modeling tools. This approach includes visual highlighting to guide the user to worst-case execution time hotspots, detailed timing information for specific model elements, and the separation of di↵erent types of timing val- ues. Our solution includes both a way to keep track of model elements subject to timing analysis during the compilation process, and a flexible and formally defined timing analysis interface for communicating timing information between a high-level modeling tool and a lower-level timing analysis tool. We present a complete open-source, Eclipse-based pro- totype tool chain that is evaluated both using a systematic benchmark suite and a user study. QC 20170124</p